#include "widget.h"
#include "ui_widget.h"
/**
  * 通用底盘测试界面程序
  * sukai
  * 2021-11-09
  * 使用前请先配置服务器ip：ip_address.txt
  * 打开控制台：
  * cp ip_address.txt /home/iimt/
 */
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

     setWindowIcon(QIcon(":/images/robot.png"));
     QString temppath_car=":/images/1_背景9.jpeg";
      QImage image_car,result_car;
      image_car.load(temppath_car);//temppath为图片的路径
      result_car = image_car.scaled(ui->label->width(), ui->label->height(),Qt::IgnoreAspectRatio, Qt::SmoothTransformation);//放缩图片，以固定大小显示
      //dbPath = ros::package::getPath("slamtec")+"/db/TABLE_OR_ROOM_POSE.db";
      // dbPath = "/home/iimt/TABLE_OR_ROOM_POSE.db";
       ui->label->setPixmap(QPixmap::fromImage(result_car));//在Label控件上显示图片
          //急停
           ui->startDisinfectlamp->setStyleSheet(tr("border-image: url(:/images/关.png);"));

           //键盘控制
           ui->keyEventjinapan->setStyleSheet(tr("border-image: url(:/images/关.png);"));
           //显示所有日志
           ui->allLog->setStyleSheet(tr("border-image: url(:/images/关.png);"));

           //建图状态
           ui->jinmap->setStyleSheet(tr("border-image: url(:/images/关.png);"));

           //启动送餐
           ui->start->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
           //返回充电
           ui->batteryChargeing->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
           //停止
           ui->stop->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
           //关机
           ui->close->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
           //帮助
           ui->help->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
           //发送指令
           ui->sendMessage->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
             //上传地图
             ui->setStcmBtn->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
             //下载地图
             ui->getStcmBtn->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
             //返回取餐点
             ui->btnBackSend->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
            //设置
             ui->setParameter->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
             //清除日志
              ui->tiaoshidemo->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
              //设置位置
               ui->setRobotPose->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               ui->next->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               ui->estop->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               ui->savemap->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));


               //对桩充电
               ui->startchargeing->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               //停止对桩
               ui->chargeingStop->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               //离桩
               ui->chargeingOff->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               //自检
               ui->automaticDetectionServer->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               //======虚拟墙=======
               ui->costMapPlayer->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               ui->getTopics->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               //======授权slam===========
               ui->registerService->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));

             ui->editFirst->addItem("请选择桌号");
             ui->editSecond->addItem("请选择桌号");
             ui->editThird->addItem("请选择桌号");
             ui->editFourth->addItem("请选择桌号");
             //设置机器人位置
        //     ui->editRobotPose->addItem("请选择当前位置");

             ui->start_KSDemoDlgTask->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));

               ui->start_KSDemoDlg->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               ui->start_SendPoseAndgetPose->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));
               ui->show_TASKPOSE->setStyleSheet(tr("border-image: url(:/images/按钮-01.png);"));

               ui->label_5->setAttribute(Qt::WA_TranslucentBackground);
               ui->label_6->setAttribute(Qt::WA_TranslucentBackground);
               ui->label_7->setAttribute(Qt::WA_TranslucentBackground);
               ui->label_8->setAttribute(Qt::WA_TranslucentBackground);
               ui->label_9->setAttribute(Qt::WA_TranslucentBackground);
               ui->startDisinfectlamp->setAttribute(Qt::WA_TranslucentBackground);
               ui->disinfectLiquidSurplusLable->setAttribute(Qt::WA_TranslucentBackground);
               ui->label_sys->setAttribute(Qt::WA_TranslucentBackground);

               QPalette pal = ui->textEdit->palette();
               //QColor(0,0,0)
               pal.setBrush(QPalette::Base, QColor(182,209,157));
               ui->textEdit->setPalette(pal);
              // ui->textEdit->setEnabled(false);

     //      QString temppath_car_j=":/images/1_背景9jj.jpeg";
      //    ui->textEdit->setHtml("<body background=" + temppath_car_j + "></body>");
              //发送指令
//               ui->sendMessageEdit->setCurrentText("请选择要发送的指令！");
//               ui->sendMessageEdit->setCurrentText("/api/moves/cancel");
//               ui->sendMessageEdit->setCurrentText("/api/markers/query_name_list");
//               ui->sendMessageEdit->setCurrentText("/api/robot_status_read");
//               ui->sendMessageEdit->setCurrentText("/api/robot_battery_bms");

     //==================业务==========================
     recv_prefix_green = "<font color='green'> &nbsp; &nbsp; &nbsp; &nbsp; "; // 空格：“&nbsp;”
     recv_prefix_red = "<font color='red'> &nbsp; &nbsp; &nbsp; &nbsp; "; // 空格：“&nbsp;”
     initWidgets() ;
     bindSignal() ;
     //回调函数
     setCallBack();

    //点位编辑
     dlg=new KSDemoDlg();
    //点位标定
     savePoseByOdom=new SavePoseByOdom();
     //查看任务
     dlgtask=new KSDemoDlgtask();
     //定时任务
     dlgtaskTme=new KSDemoDlgtaskTme();
     //设置
     dlgtaskparamer=new KSDemoDlgtaskparamer();
     //虚拟墙
     dlgtaskCostMapPlayer=new KSDemoDlgtaskCostMapPlayer();
     //授权slam
     registerService=new RegisterService();
//    IIMTDriver::getInstance();
////断开robot
//IIMTDriver::getInstance()->disConnectToRobot();

     //读取文件中的 配置数据ip地址：
     readFileGetip_address();
     //向队列中添加需要发送的tcp数据
     add_instructionQueue_sendMsg();

}
//读取文件中的 配置数据ip地址：
void Widget::readFileGetip_address(){
    //  ip_address.txt
 //读数据库 ip地址：
      //读取文件

              try {
                    //读取文件
                    QFile file(filePath);
                    if(!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
                        qDebug()<<"Can't open the file!"<<endl;
                    }
                    while(!file.atEnd()) {
                        QByteArray line = file.readLine();
                        QString msg(line);

                        //1.解析文件数据
                        //去除所有空白
                         QString  msg0 = msg.remove(QRegExp("\\s"));
                         //去掉注释,与空白的部分
                          if (msg0.contains("#")||msg0.size()==0)
                              continue;

                          if(msg0.contains(":")){
                                    QStringList msglist0 =  msg0.split(":");
                                 //   qDebug()<< msglist0;
                                    if (msglist0.size()==2){//分成两段内容
                                        if(msglist0[0]=="ip_address"){
                                           ip_address=msglist0[1];
                                        }
                                    }
                                }
                    }
                }catch(exception e){
                    qDebug()<< "读取路点数据文件 moveScript.txt 异常！";
                }
}



void Widget::initWidgets() {
    //轮询是否已经连接socket
    connectSocketTimer.setInterval(1000);
    connectSocketTimer.start();

    //定时器，获取数据 更新页面显示
    timer.setInterval(500);
    timer.start();



}

//向队列中添加需要发送的tcp数据(默认一直发送)
void Widget::add_instructionQueue_sendMsg() {



    //3.获所有地图名称
        SendMsg sendMsg3;
        sendMsg3.repeat=-1;//是否循环发送 -1:不循环 1：循环
        sendMsg3.sendMsg="/api/getMapNamelist";//需要发送的消息
        sendMsg3.logdFlg=1;//是否需要记录日志 -1:不记录日志 1：记录日志
        sendMsg3.logdMsg="获所有地图名称 sendMsg: "+sendMsg3.sendMsg;//需要记录的日志内容
        sendMsg3.logColor="get";//get:绿色 send：红色
        //添加到队列中
      instructionQueue.push(sendMsg3);

//-----------------------------------------------------------------
//1.获取当前运行状态
    SendMsg sendMsg1;
    sendMsg1.repeat=-1;//是否循环发送 -1:不循环 1：循环循环一直发送
    sendMsg1.sendMsg="/api/robot_status_read";//需要发送的消息
    sendMsg1.logdFlg=1;//是否需要记录日志 -1:不记录日志 1：记录日志
    sendMsg1.logdMsg="获取当前运行状态 sendMsg: "+sendMsg1.sendMsg;//需要记录的日志内容
    sendMsg1.logColor="get";//get:绿色 send：红色
  //添加到队列中
  instructionQueue.push(sendMsg1);
//-----------------------------------------------------------------
  //2.获取机器人信息
      SendMsg sendMsg2;
      sendMsg2.repeat=-1;//是否循环发送 -1:不循环 1：循环
      sendMsg2.sendMsg="/api/robot_info";//需要发送的消息
      sendMsg2.logdFlg=1;//是否需要记录日志 -1:不记录日志 1：记录日志
      sendMsg2.logdMsg="获取机器人信息 sendMsg: "+sendMsg2.sendMsg;//需要记录的日志内容
      sendMsg2.logColor="get";//get:绿色 send：红色
    //添加到队列中
    instructionQueue.push(sendMsg2);

//-----------------------------------------------------------------

              //4.查询定时任务
                  SendMsg sendMsg4;
                  sendMsg4.repeat=-1;//是否循环发送 -1:不循环 1：循环
                  sendMsg4.sendMsg="/api/time/query";//需要发送的消息
                  sendMsg4.logdFlg=1;//是否需要记录日志 -1:不记录日志 1：记录日志
                  sendMsg4.logdMsg="查询定时任务 sendMsg: "+sendMsg4.sendMsg;//需要记录的日志内容
                  sendMsg4.logColor="get";//get:绿色 send：红色
                  //添加到队列中
                instructionQueue.push(sendMsg4);
                //-----------------------------------------------------------------
                      //5.获取点位表数据
                          SendMsg sendMsg5;
                          sendMsg5.repeat=-1;//是否循环发送 -1:不循环 1：循环
                          sendMsg5.sendMsg="/api/markers/query_name_list";//需要发送的消息  /api/markers/query_name_list_simplify
                          sendMsg5.logdFlg=1;//是否需要记录日志 -1:不记录日志 1：记录日志
                          sendMsg5.logdMsg="获取点位表数据 sendMsg: "+sendMsg5.sendMsg;//需要记录的日志内容
                          sendMsg5.logColor="get";//get:绿色 send：红色
                          //添加到队列中
                        instructionQueue.push(sendMsg5);

                                //-----------------------------------------------------------------
                                      //7.获取任务表数据
                                          SendMsg sendMsg7;
                                          sendMsg7.repeat=-1;//是否循环发送 -1:不循环 1：循环
                                          sendMsg7.sendMsg="/api/taskpose/query_list";//需要发送的消息
                                          sendMsg7.logdFlg=1;//是否需要记录日志 -1:不记录日志 1：记录日志
                                          sendMsg7.logdMsg="获取任务表数据 sendMsg: "+sendMsg7.sendMsg;//需要记录的日志内容
                                          sendMsg7.logColor="get";//get:绿色 send：红色
                                          //添加到队列中
                                        instructionQueue.push(sendMsg7);
                                         //-----------------------------------------------------------------
                                            //6.获取设置的参数
                                                SendMsg sendMsg6;
                                                sendMsg6.repeat=-1;//是否循环发送 -1:不循环 1：循环
                                                sendMsg6.sendMsg="/api/get_params";//需要发送的消息
                                                sendMsg6.logdFlg=1;//是否需要记录日志 -1:不记录日志 1：记录日志
                                                sendMsg6.logdMsg="获取设置的参数 sendMsg: "+sendMsg6.sendMsg;//需要记录的日志内容
                                                sendMsg6.logColor="get";//get:绿色 send：红色
                                                //添加到队列中
                                              instructionQueue.push(sendMsg6);


}

//读取队列中的数据通过 tcp 发送给服务端
void Widget::read_instructionQueue_sendMsg(){
    //1.判断是否有指令
    if (instructionQueue.empty()) {
        return;
    }
    //2.取出一条指令中的夹抓状态与定时器时间
    SendMsg sendMsg = instructionQueue.front();
    //3.赋值
    int sendMsg_repeat=sendMsg.repeat;//是否循环发送 -1:不循环 1：循环
    QString  sendMsg_sendMsg=sendMsg.sendMsg;//需要发送的消息
    int  sendMsg_logdFlg=sendMsg.logdFlg;//是否需要记录日志 -1:不记录日志 1：记录日志[时时获取]
    QString  sendMsg_logdMsg=sendMsg.logdMsg;//需要记录的日志内容
    QString  sendMsg_ogColor=sendMsg.logColor;//get:绿色 send：红色

   //4.发送数据
   IIMTDriver::getInstance()->sendMsg(sendMsg_sendMsg);
   //显示日志
   show_console("发送 -> 读取队列中的数据通过 【 SendMsg sendMsg = instructionQueue.front() 】 tcp 发送给服务端 sendMsg: "+sendMsg_sendMsg,"get");
   //5.删除队列中的这条指令
    instructionQueue.pop();
   //6.重新添加到队列中  | 任务运行中存在为结束的任务时才会一直执行 ， start_clickedflg ：送餐是否有任务没结束  -1：未结束 | 1：结束

   if(sendMsg_repeat==1 && start_clickedflg==-1 ){// sendMsg_repeat=1 ： 循环

       qDebug()<<" ======================= if(sendMsg_repeat==1 && start_clickedflg==-1 ) ========================== ";

      instructionQueue.push(sendMsg);
   }

   //7.日志
   if(sendMsg_logdFlg==1){//全局变量
       qDebug()<<"sendMsg_logdFlg==1: "<<sendMsg_logdFlg;
      show_console("发送 -> "+sendMsg_logdMsg,sendMsg_ogColor);
   }

}
//向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
void Widget::add_single_instructionQueue_sendMsg(int repeat , QString sendMsg , int logdFlg, QString logdMsg, QString logColor) {
    SendMsg sendMsgTcp;
    sendMsgTcp.repeat=repeat;//是否循环发送 -1:不循环 1：循环
    sendMsgTcp.sendMsg=sendMsg;//需要tcp发送的消息
    sendMsgTcp.logdFlg=logdFlg;//是否需要记录日志 -1:不记录日志 1：记录日志
    sendMsgTcp.logdMsg=logdMsg;//需要记录的日志内容
    sendMsgTcp.logColor=logColor;//日志显示的颜色 get:绿色 send：红色
    //添加到队列中
    instructionQueue.push(sendMsgTcp);
}


void Widget::bindSignal() {
    //轮询是否已经连接socket
connect(&connectSocketTimer, &QTimer::timeout, this, &Widget::connectSocketToHostWithTime);

//定时器，获取数据 更新页面显示 循环发送 tcp 消息
connect(&timer, &QTimer::timeout, [this] {
    try {
        //确保已经连接
        if(connectfog ==1  ){


            //程序启动就获取一次地图
//            if(getMapNamelistfirst == 1 ){
//                //1.获所有地图名称
//                QString sendMsg = "/api/getMapNamelist";
//                //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
//                add_single_instructionQueue_sendMsg(-1 , sendMsg , -1, "获取当前运行状态 sendMsg: "+sendMsg, "get");
//              getMapNamelistfirst=-1;
//            }


            int fi =  ui->editFirst->currentIndex();
            int se =  ui->editSecond->currentIndex();
            int th =  ui->editThird->currentIndex();
            int fo =  ui->editFourth->currentIndex();
            if(fi==0 && se==0 &&th==0 && fo == 0 && qucaidianflg==0){
                //是否有任务没结束  -1 未结束 | 1 送餐任务已经结束
                start_clickedflg=1;

            }


            //键盘控制打开
            if(keyEventjinapanflg=="true"){
                //键盘控制打开，不能操作送餐
                ui->editFirst->setEnabled(false);
                ui->editSecond->setEnabled(false);
                ui->editThird->setEnabled(false);
                ui->editFourth->setEnabled(false);
                qDebug()<<"======键盘控制打开，不能操作送餐=======";


            }else if(keyEventjinapanflg=="false" && fi==0 && se==0 &&th==0 && fo == 0 && qucaidianflg==0 ){//返回取餐点状态qucaidianflg 1：正在返回 | 0：已经到达
                //可以执行送餐任务
                ui->editFirst->setEnabled(true);
                ui->editSecond->setEnabled(true);
                ui->editThird->setEnabled(true);
                ui->editFourth->setEnabled(true);
            }

          //建图状态
          //ui->label_sys->setText(jinmapflg);

        // fistsendMsg== 1时 等待其它数据优先发送
        if(fistsendMsg== 1)
            return ;
        //读取队列中的数据通过 tcp 发送给服务端
        read_instructionQueue_sendMsg();

        }

    } catch (std::exception e) {

    }
});

}


//回调函数
void Widget::setCallBack() {
        //IIMTDriver robot连接回调
        IIMTDriver::getInstance()->setConnectCallBack([this] {
        connectfog =1;
        //显示日志
        QString mesg = "已连接robot！ 服务器地址: "+ip_address+":"+QString::number(port);
        show_console(mesg,"get");

        //1.获取点位数据
        QString sendMsg = "/api/markers/query_name_list";
        //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
        add_single_instructionQueue_sendMsg(-1 , sendMsg , -1, "获取点位表数据 sendMsg: "+sendMsg, "get");



        });

         //IIMTDriver robot断开连接回调
        IIMTDriver::getInstance()->setDisConnectCallBack([this] {

         //显示日志
         show_console("已断开robot！","send");
         QMessageBox::about(this, tr("警告："), "robot已断开连接！");
         connectfog =-1;
        });

        //sukai 点位数据 传到函数传到ui去

        IIMTDriver::getInstance()->setTestInfos_listCallBack([this](QList<TestInfo> testInfos){
            try {
                qDebug()<<" =======================  路点数据 ========================== ";

                for (int i = 0; i <testInfos.size() ; ++i) {
//                    qDebug()<<" Id =="<<testInfos.at(i).Id;//// id
//                    qDebug()<<" TargetName =="<<testInfos.at(i).TargetName;//  点位名称：点位类型-楼层
//                    qDebug()<<" Robotfloor =="<<testInfos.at(i).Robotfloor;//// 点位名称：点位类型-楼层
//                    qDebug()<<" MerchantNumber =="<<testInfos.at(i).MerchantNumber;//// 点位名称：点位类型-楼层
//                    qDebug()<<" MerchantName =="<<testInfos.at(i).MerchantName;//// 点位名称：点位类型-楼层
//                    qDebug()<<" MapName =="<<testInfos.at(i).MapName;//// 点位名称：点位类型-楼层
//                    qDebug()<<" TypeId =="<<testInfos.at(i).TypeId;//// 点位名称：点位类型-楼层
//                    qDebug()<<" MarkNum =="<<testInfos.at(i).MarkNum;//// 点位名称：点位类型-楼层
//                    qDebug()<<" X =="<<testInfos.at(i).X;//// 点位名称：点位类型-楼层
//                    qDebug()<<" Y =="<<testInfos.at(i).Y;//// 点位名称：点位类型-楼层
//                    qDebug()<<" QZ =="<<testInfos.at(i).QZ;//// 点位名称：点位类型-楼层
//                    qDebug()<<" QW =="<<testInfos.at(i).QW;//// 点位名称：点位类型-楼层
//                    qDebug()<<" YAW =="<<testInfos.at(i).YAW;//// 点位名称：点位类型-楼层
//                    qDebug()<<" Status =="<<testInfos.at(i).Status;//// 点位名称：点位类型-楼层
                    if(testInfos.at(i).Status==testInfo_status_1){//机器人正在前往目的地
                        //机器人位置
                        ui->tagetPose->setText("正在前往: "+testInfos.at(i).TargetName);
                    }
                    if(testInfos.at(i).Status==testInfo_status_2){//机器人在目的地
                        //机器人位置
                        ui->tagetPose->setText(testInfos.at(i).TargetName);

                    }
//                    //上面代码中Qt::CaseSensitivity 为枚举类型, 可取值Qt::CaseSensitive 和 Qt::CaseInsensitive, 表示匹配的灵敏度,
//                   // Qt::CaseSensitive 代表区分大小写；Qt::CaseInsensitive 代表不区分大小，可以自行尝试；
//                   //找到普通点位 TypeId=="0" testInfos.at(i).MarkNum=="1" 不包含备用点
                    if(testInflg == 1 && testInfos.at(i).TypeId=="0" && testInfos.at(i).MarkNum=="1" && !testInfos.at(i).TargetName.contains("备用",Qt::CaseSensitive) ){
                        ui->editFirst->addItem(testInfos.at(i).TargetName);
                        ui->editSecond->addItem(testInfos.at(i).TargetName);
                        ui->editThird->addItem(testInfos.at(i).TargetName);
                        ui->editFourth->addItem(testInfos.at(i).TargetName);
                     //   qDebug()<<"  ui->editFirst->addItem=========== "<<testInfos.at(i).TargetName;//// 点位名称：点位类型-楼层


                    }
                }
                if(testInflg == 1 ){
                    //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
                    fistsendMsg= 1;
                    //2.获所有地图名称
                  //  IIMTDriver::getInstance()->sendMsg("/api/getMapNamelist");
                  //  show_console("发送 -> 获所有地图名称 sendMsg: /api/getMapNamelist","get");
                    //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; fistsendMsg= -1：队列中常用数据一直轮训发送
                    fistsendMsg= -1;
                    testInflg = -1;
                }

            } catch (std::exception e) {
                cout << " setTestInfos_listCallBack异常！" << endl;
            }

        });

        //sukai 字典数据 传到函数传到ui去
        IIMTDriver::getInstance()->setDictionarie_listCallBack([this](QList<Dictionaries> dictionaries_s){
            try {

//                int Id; //字典id号
//                QString TargetName;//名称
//                QString Key; //key
//                QString Value;//值
//                QString Status;//默认 0 状态  0：正常  -1：暂停使用ros::Subscriber

           //     qDebug()<<" =======================  字典数据 ========================== ";
         //   if(mapnameflg == 2 ){


                for (int i = 0; i <dictionaries_s.size() ; ++i) {
            //                    qDebug()<<" Id =="<<dictionaries_s.at(i).Id;//// id
            //                    qDebug()<<" TargetName =="<<dictionaries_s.at(i).TargetName;//  名称
            //                    qDebug()<<" Key =="<<dictionaries_s.at(i).Key;// key
            //                    qDebug()<<" Value =="<<dictionaries_s.at(i).Value;//值
            //                    qDebug()<<" Status =="<<dictionaries_s.at(i).Status;//默认 0 状态  0：正常  -1：暂停使用

                    //当前地图
                    if("mapName"==dictionaries_s.at(i).Key){
                       mapName=  dictionaries_s.at(i).Value;
                       ui->mapnames->setCurrentText(mapName);
                       qDebug() << "=====sususuususususus======mapName== " <<dictionaries_s.at(i).Key << ":" << dictionaries_s.at(i).Value; // 迭代器

                       }
                    //当前楼层
                    if("robotfloor"==dictionaries_s.at(i).Key){
                       robotfloor=  dictionaries_s.at(i).Value;
                       ui->getrobotfloor->setCurrentText(robotfloor);

                       ui->robotfloor->setText(robotfloor);
                  //     qDebug() << "===========robotfloor== " <<dictionaries_s.at(i).Key << ":" << dictionaries_s.at(i).Value; // 迭代器
                       }
                    //机器人编号
                    if("robotNumber"==dictionaries_s.at(i).Key){
                       QString   robotNum=  dictionaries_s.at(i).Value;
                       ui->robotNumber->setText(robotNum);
                      //机器人所在位置状态
                      testInfo_status_1= robotNum+"_1";//机器人正在前往目的地
                      testInfo_status_2= robotNum+"_2";//机器人在目的地
                    //   qDebug() << "===========robotNumber== " <<dictionaries_s.at(i).Key << ":" << dictionaries_s.at(i).Value; // 迭代器
                       }

                    //建地图服务状态 "true"  "false"
                    if("softMapState"==dictionaries_s.at(i).Key){
                       QString   softMapState=  dictionaries_s.at(i).Value;
                    //   qDebug() << "===========robotNumber== " <<dictionaries_s.at(i).Key << ":" << dictionaries_s.at(i).Value; // 迭代器
                       show_console("建地图服务状态: "+softMapState,"send");



                       if(softMapState=="true"){

                           //建地图服务 状态
                           jinmapflag_status =1;
                            //建图状态
                           ui->jinmap->setStyleSheet(tr("border-image: url(:/images/开.png);"));

                       }else if(softMapState=="false"){
                           //建地图服务 状态
                           jinmapflag_status =0;
                           //建图状态
                           ui->jinmap->setStyleSheet(tr("border-image: url(:/images/关.png);"));
                       }

                    }

                    //软急停状态 "true"  "false"
                    if("softEstopState"==dictionaries_s.at(i).Key){
                       QString   softEstopState=  dictionaries_s.at(i).Value;
                    //   qDebug() << "===========robotNumber== " <<dictionaries_s.at(i).Key << ":" << dictionaries_s.at(i).Value; // 迭代器
                       show_console("软急停状态: "+softEstopState,"send");
                       if(softEstopState=="true"){
                           // 软急停 状态
                            startDisinfectlampflag = 1;
                           //急停
                            ui->startDisinfectlamp->setStyleSheet(tr("border-image: url(:/images/关.png);"));
                       }else if(softEstopState=="false"){
                           // 软急停 状态
                            startDisinfectlampflag = 0;
                           //急停
                            ui->startDisinfectlamp->setStyleSheet(tr("border-image: url(:/images/开.png);"));
                       }

                    }
                    // 当前建图算法 1.gmapping 2.cartographer
                    if("createMapAlgorithm"==dictionaries_s.at(i).Key){
                       QString   createMapAlgorithm=  dictionaries_s.at(i).Value;
                       if(createMapAlgorithm == "1"){
                           show_console("当前建图算法 gmapping","send");
                           ui->label_sys->setText("gmapping");
                       }else if(createMapAlgorithm == "2"){
                           show_console("当前建图算法 cartographer","send");
                           ui->label_sys->setText("cartographer");
                       }else{
                          ui->label_sys->setText("未知");
                       }
                    //   qDebug() << "===========robotNumber== " <<dictionaries_s.at(i).Key << ":" << dictionaries_s.at(i).Value; // 迭代器
                       }
                }

         //     mapnameflg =-1;
        //    }





            } catch (std::exception e) {
                cout << " setDictionarie_listCallBack 行异常！" << endl;
            }


        });
        //sukai 执行路点任务 传到函数传到ui去
        IIMTDriver::getInstance()->setTaskPOSECallBack([this](QList<TaskPOSE> taskPOSEs){
            try {
            //    qDebug()<<" =======================  执行路点任务 ========================== ";
                for (int i = 0; i <taskPOSEs.size() ; ++i) {
//                    qDebug()<<" Id =="<<taskPOSEs.at(i).Id; //执行路点任务id号
//                    qDebug()<<" TaskName =="<<taskPOSEs.at(i).TaskName;//谁发的任务,第几个餐盘下发的任务
//                    qDebug()<<" RobotNumber =="<<taskPOSEs.at(i).RobotNumber; //自研底盘机器人编号： longyuan_wt_00001；思岚机器人编号 SLAMWARE-812370； WT5LS103194： 云迹 机器人编号 ；
//                    qDebug()<<" MapName =="<<taskPOSEs.at(i).MapName; //地图名字
//                    qDebug()<<" Robotfloor =="<<taskPOSEs.at(i).Robotfloor; //路点所在的当前楼层
//                    qDebug()<<" Controller =="<<taskPOSEs.at(i).Controller; //控制其它操作,比如电梯，喷雾消毒
//                    qDebug()<<" Order =="<<taskPOSEs.at(i).Order;//执行顺序
//                    qDebug()<<" TargetName =="<<taskPOSEs.at(i).TargetName; //路点名称
//                    qDebug()<<" MerchantNumber =="<<taskPOSEs.at(i).MerchantNumber;//商户编号 客户编号 比如龙源或者某个餐饮店比如海底捞1号店【每家店铺可能包含10台机器人，它们在同一个场景运行所以它们的客户编号都是一致的（方便多机协作）】
//                    qDebug()<<" MerchantName =="<<taskPOSEs.at(i).MerchantName;//商户名称
//                    qDebug()<<" TypeId =="<<taskPOSEs.at(i).TypeId; //标点类型  0：普通点 ，3：电梯外 ，4：电梯内 ，7：闸机点 ，8：电梯等待点，11：充电桩点，20：狭窄区等待点，76：减速点
//                    qDebug()<<" MarkNum =="<<taskPOSEs.at(i).MarkNum; //标点编码； 充电桩编码：存在多个充电座需要通过充电装编号来定位是那个重点装充电； 电梯编码：通过给电梯编码发送指令控制电梯
//                    qDebug()<<" X =="<<taskPOSEs.at(i).X;// 标点x坐标
//                    qDebug()<<" Y =="<<taskPOSEs.at(i).Y;//标点y坐标
//                    qDebug()<<" QZ =="<<taskPOSEs.at(i).QZ;//标点QZ 四元素
//                    qDebug()<<" QW =="<<taskPOSEs.at(i).QW;//标点QW 四元素
//                    qDebug()<<" YAW =="<<taskPOSEs.at(i).YAW;//标点欧拉角 z
//                    qDebug()<<" Status =="<<taskPOSEs.at(i).Status;//当前目标点状态  1：其它机器人正在前往该目标点，或在该目标点 ; 0：该目标点空闲，其它机器人可以前往
//                    qDebug()<<" TaskStatus =="<<taskPOSEs.at(i).TaskStatus;//当前任务状态 0：未开始  1：机器人正在前往该目标点 ; 2:机器人已经到达该点的目标备用点
//                    qDebug()<<" Time =="<<taskPOSEs.at(i).Time;//插入时间
//                    qDebug()<<" Command =="<<taskPOSEs.at(i).Command; //到目的地后需要 tcp 发送这条消息出去操作其它设备，比如机械臂
//                    qDebug()<<" CommandStatus =="<<taskPOSEs.at(i).CommandStatus;//是否启用 Command 发送tcp命令，-1：不发送Command； 1：发送Command；
//                    qDebug()<<" Message =="<<taskPOSEs.at(i).Message;//message： 接收客户端发来的消息，目标到达后完整返回给客户端
//                    qDebug()<<" SocketObjectName =="<<taskPOSEs.at(i).SocketObjectName;//记录是哪个客户端发送的命令

                }
            } catch (std::exception e) {
                cout << " setTaskPOSECallBack 行异常！" << endl;
            }

        });
        //sukai 定时任务 传到函数传到ui去
        IIMTDriver::getInstance()->setTime_taskCallBack([this](QList<Table_Task> Time_Tasks){
            try {
              //  qDebug()<<" =======================  定时任 ========================== ";
                for (int i = 0; i <Time_Tasks.size() ; ++i) {
  //                  qDebug()<<" Id =="<<Time_Tasks.at(i).Id;//id唯一号
//                    qDebug()<<" RobotNumber =="<<Time_Tasks.at(i).RobotNumber;//机器人编号 SLAMWARE-812370
//                    qDebug()<<" Equipment_1 =="<<Time_Tasks.at(i).Equipment_1;//设备1   //紫外灯消毒是否开启 开启，关闭 Disinfectlamp
//                    qDebug()<<" Equipment_2 =="<<Time_Tasks.at(i).Equipment_2;//设备2   喷雾是否开启 开启，关闭 Spray
//                    qDebug()<<" TargetName =="<<Time_Tasks.at(i).TargetName;//路点名称 //区域号 Area
//                    qDebug()<<" StartTime =="<<Time_Tasks.at(i).StartTime;//开始时间 "202105241657"【格式】精确到分
//                    qDebug()<<" EndTime =="<<Time_Tasks.at(i).EndTime;//结束时间 "202105241657"【格式】精确到分
//                    qDebug()<<" Status =="<<Time_Tasks.at(i).Status;//开始标志 开启，关闭
//                    qDebug()<<" WorkingStatus =="<<Time_Tasks.at(i).WorkingStatus;//是否正在执行 正在运行 ，停止
                }

            } catch (std::exception e) {
                cout << " setTime_taskCallBack 行异常！" << endl;
            }

        });
        //sukai 获取地图名称 传到函数传到ui去
        IIMTDriver::getInstance()->setMapNames_listCallBack([this](QList<QMap<QString,std::vector<std::string>>> mapNames_listCallBack){
            try {
                     mapNames_list =mapNames_listCallBack;
                     if(mapnameflg == 1 ){
                         ui->mapnames->clear();
                         for (int i = 0; i <mapNames_listCallBack.size() ; ++i) {
                                             QMap<QString,std::vector<std::string>>::const_iterator iter = mapNames_listCallBack.at(i).begin();
                                                  while (iter != mapNames_listCallBack.at(i).end())
                                                  {
                                                     // qDebug() << "===========Iterator== " << iter.key() << ":" << iter.value(); // 迭代器
                                                      //设置1及地图名称
                                                      ui->mapnames->addItem(iter.key());
                                                      iter++;
                                                  }

                         }

//                         //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
//                            fistsendMsg= 1;
//                            //3.获取设置的参数
//                            IIMTDriver::getInstance()->sendMsg("/api/get_params");
//                            show_console("发送 -> 获取设置的参数 sendMsg: /api/get_params","get");
//                            mapnameflg =2;
//                            qDebug()<<"=====testInflg: "<<testInflg;

//                            //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
//                            fistsendMsg= -1;
                     }

            } catch (std::exception e) {
                cout << "setMapNames_listCallBack 行异常！" << endl;
            }

        });
        //sukai 到达点位后返回的数据 传到函数传到ui去
        IIMTDriver::getInstance()->setArriveRobotCallBack([this](ArriveRobot arriveRobot){
            try {

                       qDebug()<<" ========arrive===============  到达点位后返回的数据 =====arrive===================== ";
                       qDebug()<<"ui arriveRobot.arriveType "<<arriveRobot.arriveType;// tcp客户端名字->发送的命令
                       qDebug()<<"ui arriveRobot.arriveObjectName "<<arriveRobot.arriveObjectName;// 取第几个托盘,发送/api/markers/insert未传递对应的task将返回 EMPTY
                       qDebug()<<"ui arriveRobot.arriveTaskName "<<arriveRobot.arriveTaskName;// 到达的房间
                       qDebug()<<"ui arriveRobot.arrivetargetName "<<arriveRobot.arrivetargetName;//到目的地后需要 tcp 发送这条消息出去操作其它设备，比如机械臂
                       qDebug()<<"ui arriveRobot.arriveCommand "<<arriveRobot.arriveCommand;//是否启用 Command 发送tcp命令，-1：不发送Command； 1：发送Command；
                       qDebug()<<"ui arriveRobot.arriveCommandStatus "<<arriveRobot.arriveCommandStatus;//是否启用 Command 发送tcp命令，-1：不发送Command； 1：发送Command；
                       qDebug()<<"ui arriveRobot.arriveMessage "<<arriveRobot.arriveMessage;//message： 接收客户端发来的消息，目标到达后完整返回给客户端
                       qDebug()<<"ui arriveRobot.arriveStatus "<<arriveRobot.arriveStatus;//success: 成功 ； aborted：未到达目的地；  preempted：用户取消操作
                       qDebug()<<" ========arrive===============  到达点位后返回的数据 =====arrive===================== ";
                       if(arriveRobot.arriveTaskName=="第一层托盘"){
                           ui->editFirst->setCurrentIndex(0);
                       }else if(arriveRobot.arriveTaskName=="第二层托盘"){
                           ui->editSecond->setCurrentIndex(0);
                       }else if(arriveRobot.arriveTaskName=="第三层托盘"){
                           ui->editThird->setCurrentIndex(0);
                       }else if(arriveRobot.arriveTaskName=="第四层托盘"){
                           ui->editFourth->setCurrentIndex(0);

                       }else if(arriveRobot.arriveTaskName=="取餐点"){
                           //返回取餐点状态 1：正在返回 | 0：已经到达
                              qucaidianflg=0;

                       }


                   //    if(logall==1){
                           //显示日志
                           QString mesg="接收  到达点位后返回的数据 arriveRobot.arriveTaskName: "+arriveRobot.arriveTaskName +" |arriveRobot.arriveMessage: "+arriveRobot.arriveMessage+"| arriveRobot.arriveStatus: "+arriveRobot.arriveStatus;
                           show_console(mesg,"send");

                     //  }
                           //1.获取点位表数据
                           QString sendMsg = "/api/markers/query_withStatus_ne_zero";

                           //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
                           add_single_instructionQueue_sendMsg(-1 , sendMsg , -1, "获取点位表数据 sendMsg: "+sendMsg, "get");


            } catch (std::exception e) {
                cout << "setArriveRobotCallBack 行异常！" << endl;
            }

        });
        //sukai 机器人的一些基本信息 传到函数传到ui去
        IIMTDriver::getInstance()->setRobot_infoCallBack([this](Robot_info robot_info){
            try {
                qDebug()<<" ======================= 机器人的一些基本信息 ========================== ";
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.robotNumber;//机器人编号
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.merchantNumber;//商户编号
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.merchantName;//商户名称
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.velspeed; //机器人线速度
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.angularSpeed; //机器人角速度
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.ip_address; //机器人热点地址
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.ip_address_prot; //机器人端口
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.waitGoalTime; //每个目标点停留的时间 当：waitIsNotGo：-1 时 ； waitGoalTime 无效
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.waitIsNotGo; // waitIsNotGo = 1：到达目标点后自动运行下一个点， -1：不自动运行下一个点 ； | waitIsNotGo：-1 时 waitGoalTime 无效
                qDebug()<<"ui arriveRobot.arriveType "<<robot_info.enableFlag; // 软急停 电机使能true 电机失能false



                 enableFlag=robot_info.enableFlag;
                 ui->dianjishineng->setText(enableFlag);

                 if(logall==1){
                     //显示日志
                     QString mesg="接收  机器人的一些基本信息 robot_info.merchantName: "+robot_info.merchantName+" | robot_info.waitGoalTime: "+robot_info.waitGoalTime+" | robot_info.waitIsNotGo: "+robot_info.waitIsNotGo+" | robot_info.enableFlag: "+robot_info.enableFlag;
                     show_console(mesg,"send");
                     qDebug()<<"mesg:内 "<<mesg;
                 }

            } catch (std::exception e) {
                cout << "setRobot_infoCallBack 行异常！" << endl;
            }

        });
        //sukai 小车的运行状态 传到函数传到ui去
        IIMTDriver::getInstance()->setRobot_statusCallBack([this](QString robot_status){
            try {

//                       类型	说明
//                        ActionStatusWaitingForStart	动作正在等待开始。
//                        ActionStatusRunning	动作正在进行。
//                        ActionStatusFinished	动作已经完成。
//                        ActionStatusPaused	动作已经暂停。
//                        ActionStatusStopped	动作已经停止（取消）。
//                        ActionStatusError	动作执行过程中出现错误。
//                        LOST  刚启动程序，就是输出LOST；

                qDebug()<<" =======================  小车的运行状态 ========================== ";
                qDebug()<<"ui 小车的运行状态 robot_status "<<robot_status;// tcp客户端名字->发送的命令
                 robotStatus = robot_status;
              //   ui->robot_status->setText(robotStatus);

                 if(robotStatus=="ActionStatusRunning"){
                  ui->robot_status->setText("动作正在进行");
                 }else if(robotStatus=="ActionStatusFinished"){
                   ui->robot_status->setText("动作已经完成!");
                 }else if(robotStatus=="ActionStatusStopped"){
                     ui->robot_status->setText("动作已经停止（取消）!");
                   }else if(robotStatus=="ActionStatusError"){
                     ui->robot_status->setText("动作执行过程中出现错误!");
                   }else if(robotStatus=="解析json文件错误"){
                        show_console("*****==============解析json文件错误==================******","send");
                 }

             //    if(logall==1){
                     //显示日志
                     QString mesg="接收 小车的运行状态 robot_statusCallBack: "+robotStatus;
                     show_console(mesg,"send");
             //    }

                     //1.获取点位表数据
                     //QString sendMsg = "/api/markers/query_name_list";
                     //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
                   //  add_single_instructionQueue_sendMsg(-1 , sendMsg , -1, "获取点位表数据 sendMsg: "+sendMsg, "get");

            } catch (std::exception e) {
                cout << " setRobot_statusCallBack 行异常！" << endl;
            }

        });

        //sukai 保存地图后反馈ui去
        IIMTDriver::getInstance()->setRobot_saveGmappingMap_CallBack([this](SaveGmappingMap saveGmappingMap){
            try {

                qDebug()<<" =======================  保存地图后反馈 ========================== ";
              //   ui->robot_status->setText(robotStatus);

                 if(saveGmappingMap.status=="OK"){
                    QMessageBox::about(this, tr("提示："), "保存地图成功！");

                      //1.获所有地图名称
                      QString sendMsg = "/api/getMapNamelist";
                      //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
                      add_single_instructionQueue_sendMsg(-1 , sendMsg , -1, "保存地图后的反馈 sendMsg: "+sendMsg, "get");
                 }else {
                     QMessageBox::about(this, tr("警告："), "保存地图失败！");
                 }

                 if(logall==1){
                     //显示日志
                     QString mesg="接收 保存地图后反馈状态 robot_saveGmappingMap_CallBac mapName: "+saveGmappingMap.mapName+" robotfloor: "+saveGmappingMap.robotfloor;
                     show_console(mesg,"send");
                 }

                     //1.获取点位表数据
                     QString sendMsg = "/api/markers/query_name_list";
                     //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
                     add_single_instructionQueue_sendMsg(-1 , sendMsg , -1, "获取点位表数据 sendMsg: "+sendMsg, "get");

            } catch (std::exception e) {
                cout << " setRobot_statusCallBack 行异常！" << endl;
            }

        });

        //sukai 获取所有运行的node节点的名称 传到函数传到ui去
        IIMTDriver::getInstance()->setNodeName_listCallBack([this](QList<QString> nodeName_listCallBack){
            try {
                             //显示日志
                            QString mesg1=" 正在运行的节点名或topic名：";
                            show_console(mesg1,"send");
                         for (int i = 0; i <nodeName_listCallBack.size() ; ++i) {
                                 QString mesg="【 "+nodeName_listCallBack[i]+" 】";
                                 show_console(mesg,"get");
                         }
                         QString mesg2="============================================================ ";
                         show_console(mesg2,"send");
            } catch (std::exception e) {
                cout << "setNodeName_listCallBack 行异常！" << endl;
            }

        });

        //sukai 收到的所有数据 传到函数传到ui去
        IIMTDriver::getInstance()->setMsgba_CallBack([this](QString msgba){
            try {
                        if(logall==1){
                            //显示日志
                            show_console(msgba,"send");
                             }
             //           qDebug() << "===========IIMTDriver 29行解析返回的数据 socket.bytesAvailable(): ==========="<<  socket.bytesAvailable();

                            QJsonParseError parseJsonErr;
                            QJsonDocument document = QJsonDocument::fromJson(msgba.toUtf8(),&parseJsonErr);
                            if(!(parseJsonErr.error == QJsonParseError::NoError))
                            {
                                qDebug()<<"widget.cpp解析json文件错误！";
                                return;
                            }
                            QJsonObject jsonObject = document.object();
                            QString type = jsonObject["type"].toString();
                            //接收串口过来的红外数据
                            if(  jsonObject["command"].toString()=="/api/driverCharing"){
                                if(jsonObject["status"].toString()=="OK"){
                                    QString leftFirst = jsonObject["leftFirst"].toString();//
                                    QString leftSecond = jsonObject["leftSecond"].toString();//
                                    QString leftThird = jsonObject["leftThird"].toString();//
                                    QString middleFirst = jsonObject["middleFirst"].toString();//
                                    QString middleSecond = jsonObject["middleSecond"].toString();//
                                    QString middleThird = jsonObject["middleThird"].toString();//
                                    QString rightFirst = jsonObject["rightFirst"].toString();//
                                    QString rightSecond = jsonObject["rightSecond"].toString();//
                                    QString rightThird = jsonObject["rightThird"].toString();//
                                    QString proximity = jsonObject["proximity"].toString();//

                                    QString msgleft=leftFirst+" "+leftSecond+" "+leftThird;
                                    QString msgmiddle=middleFirst+" "+middleSecond+" "+middleThird;
                                    QString msgright=rightFirst+" "+rightSecond+" "+rightThird;
                                    QString msgproximity=proximity;

                                    //显示日志
                                    show_console("===红外数据===","get");
                                    show_console(msgleft,"get");
                                    show_console(msgmiddle,"get");
                                    show_console(msgright,"get");
                                    show_console(msgproximity,"get");
                                }

                            }else if( jsonObject["command"].toString()=="/api/automaticDetection_result"){
                                    if(jsonObject["status"].toString()=="error"){
                                        QString number = jsonObject["number"].toString();
                                        QJsonValue jsonValueList = jsonObject.value(QString::fromStdString("results"));
                                        QJsonObject item = jsonValueList.toObject();
                                        if(item.contains(QString::fromStdString("automaticDetectionList"))){
                                            QJsonValue jsonValueList1 = item.value(QString::fromStdString("automaticDetectionList"));
                                            const QJsonArray &array = jsonValueList1.toArray();
                                            show_console("===========================robot自检测============================","send");
                                            for (int i = 0; i <array.size() ; ++i) {
                                                qDebug()<<"获取所有未启动的的 node节点服务"<< array.at(i).toString();
                                                //显示日志

                                                show_console(array.at(i).toString(),"send");
                                            }
                                            show_console("=================================================================","send");
                                        }
                                    }else{
                                        QString number = jsonObject["number"].toString();
                                        QJsonValue jsonValueList = jsonObject.value(QString::fromStdString("results"));
                                        QJsonObject item = jsonValueList.toObject();
                                        if(item.contains(QString::fromStdString("automaticDetectionList"))){
                                            QJsonValue jsonValueList1 = item.value(QString::fromStdString("automaticDetectionList"));
                                            const QJsonArray &array = jsonValueList1.toArray();
                                            show_console("===========================robot自检测============================","get");
                                            for (int i = 0; i <array.size() ; ++i) {
                                                qDebug()<< array.at(i).toString();
                                                //显示日志

                                                show_console(array.at(i).toString(),"get");
                                            }
                                            show_console("=================================================================","get");
                                        }
                                    }
                            }else if( jsonObject["command"].toString()=="/api/car_robot_status_describe"){//获取小车当前的运行状态描述|机器人运行状态描述 正在运行到哪个点位，已经到达哪个点位
                                        if(jsonObject["status"].toString()=="OK"){
                                            QString result = jsonObject["result"].toString();
                                            //机器人位置|机器人运行状态描述
                                            ui->tagetPose->setText(result);

                                        }
                            }else if( jsonObject["command"].toString()=="/api/markers/query_withStatus_ne_zero"){//获取marker点位,状态不为0的数据，该目标点不为空闲的列表数据,判断小车当前状态
                                if(jsonObject["status"].toString()=="OK" ){
                                    QString number = jsonObject["number"].toString();
                                    if(jsonObject.contains(QString::fromStdString("results")))
                                    {
                                        QJsonValue jsonValueList = jsonObject.value(QString::fromStdString("results"));
                                        QJsonObject item = jsonValueList.toObject();
                                        if(item.contains(QString::fromStdString("meeting_room"))){
                                            QJsonValue jsonValueList1 = item.value(QString::fromStdString("meeting_room"));
                                            const QJsonArray &array = jsonValueList1.toArray();
                                            for (int i = 0; i <array.size() ; ++i) {
                                                            QString   testInfomarkname=array.at(i).toObject().value("marker_name").toString();//标点名称
                                                            QString   mapName=array.at(i).toObject().value("mapName").toString();//地图名字
                                                            QString   floor=array.at(i).toObject().value("floor").toString();//点位所在的当前楼层
                                                             QString  testInstatus=array.at(i).toObject().value("status").toString(); //当前目点位状态
                                                             if(testInstatus==testInfo_status_1){//机器人正在前往目的地
                                                                 //机器人位置
                                                                 ui->tagetPose->setText("正在前往: "+testInfomarkname);
                                                             }
                                                             if(testInstatus==testInfo_status_2){//机器人在目的地
                                                                 //机器人位置
                                                                 ui->tagetPose->setText(testInfomarkname);

                                                             }

                                            }

                                        }

                                    }
                                }
                    }



            } catch (std::exception e) {
                cout << "setNodeName_listCallBack 行异常！" << endl;
            }

        });
        //================================KSDemoDlg=======================================
}




//1.socket连接 轮询是否已经连接socket
void Widget::connectSocketToHostWithTime(){
    try {
        if(connectfog !=1){
             qDebug()<<"====socket==尝试次连接==============";
            //连接robot ip
          // IIMTDriver::getInstance()->connectToRobot(ipEdit.text(), portEdit.text().toInt());

             if(ip_address.size()>0){
                 IIMTDriver::getInstance()->connectToRobot(ip_address, port);
                 if(logall==1){
                     //显示日志
                     QString mesg="socket 尝试再次连接 ip_address: "+ip_address+":"+QString::number(port);
                     show_console(mesg,"send");
                 }
             }
         //   IIMTDriver::getInstance()->connectToRobot("127.0.0.1", 31001);
          //  socket->connectToHost("127.0.0.1", 31001);// 龙源TCP连接方式

         }
    } catch (exception e) {

    }


}





//初始话
void Widget::initvariable(){
    connectfog=-1;

}
/**
 * 显示日志
 */

void Widget::show_console(QString msg_log,QString send) {

    try {
        char response[5520];
        time_t tt;
        char buf[16] = {0};
        char buf1[16] = {0};
        tt = time(NULL);
        strftime(buf, 16, "%y-%m-%d %H:%M:%S", localtime(&tt));

        sprintf(response, "[本地时间: %s ]", buf);
        if (send == "send") {//发送消息
            // todo 显示日志
         ui->textEdit->append(recv_prefix_red + response + msg_log);
        } else if (send == "get") {//接收到消息
            // todo 显示日志
         ui->textEdit->append(recv_prefix_green + response + msg_log);
        }

        QString msg1 = QString(buf);
        msg1 = "[本地时间: "+msg1+"] "+msg_log;
        QByteArray array = msg1.toLocal8Bit();
        sprintf(response ,array);
        strftime(buf1, 16, "%y_%m_%d", localtime(&tt));
        QString logfileTimeName = QString(buf1);
       //todo sukai暂时不储存
     //   Log_Save(response,logfileTimeName);
    } catch (exception e) {

    }


}

/**
 * 保存日志
 * showLog1
 */
void Widget::Log_Save(const char*str,QString logfileTimeName)
{

//自动创建目录
//--------------------还没测试-----------------------------

    try {
        char file_path[1500] = {0};
        std::string home = getenv("HOME");
        std::string log_file_path = home + "/Log_robot/";
        const char *str1 = log_file_path.c_str();
        memcpy(&file_path, str1, sizeof(log_file_path));
        if(access(file_path, F_OK) != 0) {     //目录不存在
            std::string build_path ="mkdir -p ";
            build_path += file_path;
            system(build_path.c_str());
          //  assert(system(build_path.c_str()) !=0 );//程序会退出
        }

        QString OutTxt(str);
        QString filepath1=QString::fromStdString(log_file_path)+logfileTimeName+"A.txt";
        QString filepath2=QString::fromStdString(log_file_path)+logfileTimeName+"B.txt";

        QFile outFile1((filepath1));
        QFile outFile2((filepath2));
        outFile1.open(QIODevice::WriteOnly | QIODevice::Append);
        if(outFile1.size() >= 1024*100)
        {
            outFile1.close();
            outFile2.remove();
            QFile::copy((filepath1),(filepath2));
            outFile1.remove();
            QFile outFile3((filepath1));
            outFile3.open(QIODevice::WriteOnly | QIODevice::Append);
            QTextStream ts(&outFile3);
            ts.setCodec(QTextCodec::codecForName("UTF-8"));
            ts << OutTxt << endl;
        }
        else
        {
            QTextStream ts(&outFile1);
            ts.setCodec(QTextCodec::codecForName("UTF-8"));
            ts << OutTxt << endl;
        }

    }catch (std::exception e){

    }

//-------------------------------------------------


}
/**
 * 清除日志
 */
void Widget::clear_log() {

   // logTextEdit.clear();
}

Widget::~Widget()
{
    delete ui;
}



//启动机器人 开始送餐
void Widget::on_start_clicked()
{
    try {
        if(keyEventjinapanflg=="true"){
         QMessageBox::about(this, tr("警告："), "请关闭键盘控制！");
            return;
        }

        if(start_clickedflg==-1){
               QMessageBox::about(this, tr("提示："), "当前有任务正在执行，请等待任务完成或这停止任务");
               return;
        }


        int fi =  ui->editFirst->currentIndex();
        int se =  ui->editSecond->currentIndex();
        int th =  ui->editThird->currentIndex();
        int fo =  ui->editFourth->currentIndex();
        if(fi==0 && se==0 &&th==0 && fo == 0 ){
            //是否有任务没结束
            QMessageBox::about(this, tr("提示："), "请选择左侧的托盘任务！");
             return;
        }
       //按钮变灰
        ui->editFirst->setEnabled(false);
        ui->editSecond->setEnabled(false);
        ui->editThird->setEnabled(false);
        ui->editFourth->setEnabled(false);



        //送餐任务开始改变状态 start_clickedflg=-1 | 是否有任务没结束 -1 未结束
         start_clickedflg=-1;

        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        qDebug()<<"启动机器人";
        //api/move?location=15.0,4.0,1.5707963
        //  QString mage="/api/move?marker=111,222,333,444,555,555,666&task=第一层托盘,第二层托盘,第三层托盘,第四层托盘,第5层托盘,第6层托盘,第7层托盘&count=3";
        //	/api/move?marker=target_name,target_name1,target_name2...&task=task_name,task_name1,task_name2...&message=message,message1,message2...&count=3
        QString mage="/api/moves?";
     //  QString mage="/api/move?";
        QString task="task=";
        QString marker="marker=";
        QString message="message=";
        QList<QString> tasks;
        QList<QString> markers;
        QList<QString> messages;
           //第一层
           int editFirstIndex = ui->editFirst->currentIndex();
           //   qDebug()<<"editFirst->currentIndex:" <<editFirstIndex;
            QString editFirstMsg = ui->editFirst->currentText();
            int indexedit=0;
            if(editFirstIndex!=0){
                //添加
                tasks.push_back("第一层托盘");
                messages.push_back("SH_56_001");//指令，把这条数据发个服务器下位机，目标点到达后在返回给客户端
                markers.push_back(editFirstMsg);

                indexedit++;
                }
            //第二层
            int editSecondIndex = ui->editSecond->currentIndex();
             //   qDebug()<<"editSecond->currentIndex:" <<editSecondIndex;
            QString editSecondMsg = ui->editSecond->currentText();
              //  qDebug()<<"editSecond:" <<editSecondMsg;
            if(editSecondIndex!=0){
                //添加
                tasks.push_back("第二层托盘");
                messages.push_back("SH_56_002");//指令，把这条数据发个服务器下位机，目标点到达后在返回给客户端
                markers.push_back(editSecondMsg);

                indexedit++;
                }
            //第三层
            int editThirdIndex = ui->editThird->currentIndex();
            // qDebug()<<"editThird->currentIndex:" <<editThirdIndex;
            QString editThirdMsg = ui->editThird->currentText();
            if(editThirdIndex!=0){
                //添加
                tasks.push_back("第三层托盘");
                messages.push_back("SH_56_003");//指令，把这条数据发个服务器下位机，目标点到达后在返回给客户端
                markers.push_back(editThirdMsg);

                indexedit++;
                }
            //第四层
            int editFourthIndex = ui->editFourth->currentIndex();
            QString editFourthMsg = ui->editFourth->currentText();
            if(editFourthIndex!=0){
                //添加
                tasks.push_back("第四层托盘");
                messages.push_back("SH_56_004");//指令，把这条数据发个服务器下位机，目标点到达后在返回给客户端
                markers.push_back(editFourthMsg);
                indexedit++;
                }
            //有tasks
            if(markers.size()>0&&markers.size()==tasks.size()&&markers.size()==messages.size()){
                for (int i=0;i<markers.size();i++) {
                    if(i==(markers.size()-1)){
                        marker=marker+markers[i];
                        task=task+tasks[i];
                        message=message+messages[i];
                    }else if(i<(markers.size()-1)){
                        marker=marker+markers[i]+",";
                        task=task+tasks[i]+",";
                        message=message+messages[i]+",";
                    }
                }
               //菜品送给客户完成后，返回取餐点
                //从字典中取值 取餐点
                 QString originName = IIMTDriver::getInstance()->dictionariesMap_ui["originName"];
                 if(originName.size()>0){
                       marker=marker+","+originName;//机器人返回原点;
                       task=task+","+originName;//机器人返回原点;
                       message=message+",empty";

                  }


            }else if(markers.size()>0){//
                for (int i=0;i<markers.size();i++) {
                    if(i==(markers.size()-1)){
                        marker=marker+markers[i];//最后一位不加 ","
                    }else if(i<(markers.size()-1)){
                        marker=marker+markers[i]+",";
                    }

                }
                 // 从字典中取值 取餐点
                   QString originName = IIMTDriver::getInstance()->dictionariesMap_ui["originName"];
                   if(originName.size()>0){
                         marker=marker+","+originName;//机器人返回原点;
                    }

            }
             if(markers.size()>0){
                  //返回取餐点状态 1：正在返回 | 0：已经到达
                 qucaidianflg=1;
                 mage=mage+marker+"&"+task+"&"+message;
        //       ui->start->setEnabled(false);
        //       ui->batteryChargeing->setEnabled(false);
        //       ui->close->setEnabled(false);
        //       ui->btnBackSend->setEnabled(false);



               //向无人车发送消息
                 IIMTDriver::getInstance()->sendMsg(mage);
                 //显示日志
                 QString mesglog="发送 -> 开始送餐 sendMsg： "+mage;
                 show_console(mesglog,"get");

                 //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
              //   add_single_instructionQueue_sendMsg(-1 , mage , 1, mesglog, "get");

                 //1.获取当前运行状态 sukai ；不使用调一次回一次的方法；使用 /api/car_robot_status
              //   QString sendMsg_yun = "/api/robot_status_read";
                 //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
                // add_single_instructionQueue_sendMsg(1 , sendMsg_yun , -1, "获取当前运行状态 sendMsg: "+sendMsg_yun, "get");
             }else{
                 //显示日志
                 QString mesglog="请选择要送餐的房间 ";
                 show_console(mesglog,"send");
             }
             //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
             fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }


}
//停止 取消任务
void Widget::on_stop_clicked()
{
    try {
//        if(keyEventjinapanflg=="true"){
//         QMessageBox::about(this, tr("警告："), "请关闭键盘控制！");
//            return;
//        }

        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        //初始化2
        initWidget2();
         QString mage="/api/moves/cancel";
        //  QString mage="/api/move/cancel";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 停止,取消任务 sendMsg： "+mage;
          show_console(mesglog,"send");


          //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }

}
//返回取餐点
void Widget::on_btnBackSend_clicked()
{

    try {
        if(keyEventjinapanflg=="true"){
         QMessageBox::about(this, tr("警告："), "请关闭键盘控制！");
            return;
        }


        if(start_clickedflg==-1){
             QMessageBox::about(this, tr("提示："), "当前有任务正在执行，请等待任务完成或这停止任务");
             return;
        }


        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        //返回取餐点状态 1：正在返回 | 0：已经到达
        qucaidianflg=1;

        //送餐按钮变灰
         ui->editFirst->setEnabled(false);
         ui->editSecond->setEnabled(false);
         ui->editThird->setEnabled(false);
         ui->editFourth->setEnabled(false);


        QString mage="/api/moves?";
        QString task="task=";
        QString marker="marker=";
        QString message="message=";
        //从字典中取值 取餐点
         QString originName = IIMTDriver::getInstance()->dictionariesMap_ui["originName"];
         if(originName.size()>0){
               marker=marker+originName;//机器人返回原点;
               task=task+originName;//机器人返回原点;
               message=message+"empty";


           mage=mage+marker+"&"+task+"&"+message;
         //向无人车发送消息
           IIMTDriver::getInstance()->sendMsg(mage);
           //显示日志
           QString mesglog="发送 -> 返回取餐点 sendMsg： "+mage;
           show_console(mesglog,"get");

           //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
          // add_single_instructionQueue_sendMsg(-1 , mage , 1, mesglog, "get");
            }
           //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
           fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }

}
//执行下一个任务 多个点，依次执行时，发送此命令可以跳过等待时间
void Widget::on_next_clicked()
{

    if(keyEventjinapanflg=="true"){
     QMessageBox::about(this, tr("警告："), "请关闭键盘控制！");
        return;
    }
    // 注意： 执行下一个任务不走队列  add_single_instructionQueue_sendMsg(-1 , mage , 1, mesglog, "get");
    try {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        QString mage="/api/moves/next";
        //向无人车发送消息
      IIMTDriver::getInstance()->sendMsg(mage);

        //显示日志
        QString mesglog="发送 -> 执行下一个任务 sendMsg： "+mage;
       show_console(mesglog,"get");
       //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
       fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }

}



//重启
void Widget::on_close_clicked()
{
    if(keyEventjinapanflg=="true"){
     QMessageBox::about(this, tr("警告："), "请关闭键盘控制！");
        return;
    }
// 注意： 重启也不走队列  add_single_instructionQueue_sendMsg(-1 , mage , 1, mesglog, "get");
    try {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        QString mage="/api/restart";
        //向无人车发送消息
        IIMTDriver::getInstance()->sendMsg(mage);

        //显示日志
        QString mesglog="发送 -> 重启 sendMsg： "+mage;
        show_console(mesglog,"get");
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;

    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }

}
//刷新
void Widget::on_estop_clicked()
{

    try {
        //初始化
        initWidget();
        //显示日志
        QString mesglog="刷新 ";
        show_console(mesglog,"get");
    } catch (exception e) {

    }


}
//初始化
void Widget::initWidget(){

    try {
        //初始化数据
        add_instructionQueue_sendMsg();
        testInflg = 1;
        mapnameflg = 1;
        //取餐点flg
        qucaidianflg=0;
        //程序启动就获取一次地图
        getMapNamelistfirst = 1;
      //  robotStatus="";
        //机器人位置
        ui->tagetPose->setText("");
        ui->editFirst->clear();
        ui->editSecond->clear();
        ui->editThird->clear();
        ui->editFourth->clear();
        ui->editFirst->addItem("请选择桌号");
        ui->editSecond->addItem("请选择桌号");
        ui->editThird->addItem("请选择桌号");
        ui->editFourth->addItem("请选择桌号");
          qDebug()<<"刷新: "<<testInflg;
    } catch (exception e) {

    }


}
//初始化2
void Widget::initWidget2(){

    try {
        //初始化数据
      //  add_instructionQueue_sendMsg();
       // testInflg = 1;
       // mapnameflg = 1;

        //程序启动就获取一次地图
      //  getMapNamelistfirst = 1;
      //  robotStatus="";

           //  第一层托盘
            ui->editFirst->setCurrentIndex(0);
           //  第二层托盘
            ui->editSecond->setCurrentIndex(0);
            //   第三层托盘
            ui->editThird->setCurrentIndex(0);
             //   第四层托盘
            ui->editFourth->setCurrentIndex(0);
            //返回取餐点状态 1：正在返回 | 0：已经到达
               qucaidianflg=0;


        //按钮变灰
         ui->editFirst->setEnabled(true);
         ui->editSecond->setEnabled(true);
         ui->editThird->setEnabled(true);
         ui->editFourth->setEnabled(true);
          qDebug()<<"刷新2: "<<testInflg;
    } catch (exception e) {

    }


}

//位点编辑
void Widget::on_start_KSDemoDlg_clicked()
{
    try {
        dlg->show();

        //显示日志
        QString mesglog="位点编辑 dlg->show()";
        show_console(mesglog,"get");

    } catch (exception e) {

    }

}
//点位标定
void Widget::on_start_SendPoseAndgetPose_clicked()
{
    try {
        qDebug()<<"点位标定";
        savePoseByOdom->show();
        //显示日志
        QString mesglog="点位标定 savePoseByOdom->show()";
        show_console(mesglog,"get");
    } catch (exception e) {

    }




}
//查看任务
void Widget::on_show_TASKPOSE_clicked()
{
    try {
        dlgtask->show();
        //显示日志
        QString mesglog="查看任务 dlgtask->show()";
        show_console(mesglog,"get");
    } catch (exception e) {

    }


}

//设置
void Widget::on_setParameter_clicked()
{

    try {
        dlgtaskparamer->show();
            //显示日志
            QString mesglog="设置 dlgtaskparamer->show()";
            show_console(mesglog,"get");
    } catch (exception e) {

    }



}

void Widget::on_mapname_destroyed()
{
    qDebug()<<"on_mapname_destroyed";
}

void Widget::on_mapnames_activated(const QString &arg1)
{
 //  qDebug()<<arg1;
}

void Widget::on_mapnames_currentIndexChanged(const QString &arg1)
{


    try {
        qDebug()<<"===222223444= "<<arg1;
             if(arg1<=0)
                 return;
            // mapNames_list = IIMTDriver::getInstance()->mapNames_list;//获所有地图名称
              qDebug()<<"===1======= "<<arg1;
              if(mapNames_list.size()<=0)
                  return;

             for (int i = 0; i <mapNames_list.size() ; ++i) {
                  qDebug()<<"===2======= "<<arg1;
                                 QMap<QString,std::vector<std::string>>::const_iterator iter = mapNames_list.at(i).begin();
                                  qDebug()<<"===3======= "<<arg1;
                                      while (iter != mapNames_list.at(i).end())
                                      {
                                           qDebug()<<"===4======= "<<arg1;
                                         if(iter.key()==arg1){
                                              qDebug()<<"===5======= "<<arg1;
                                             ui->getrobotfloor->clear();
                                              qDebug()<<"===6======= "<<arg1;

                                              if(iter.value().size()<=0)
                                                  return;


                                              for (int i = 0; i <iter.value().size() ; ++i) {
                                                   qDebug()<<"===8======= "<<arg1;
                                                  //设置2及地图楼层
                                                   if(iter.value().at(i).size()<=0)
                                                       return;

                                                   ui->getrobotfloor->addItem(QString::fromStdString(iter.value().at(i)));
                                                   qDebug()<<"===9======= "<<arg1;
                                                    qDebug()<<"===10====robotfloor=== "<<robotfloor;
                                                    if(robotfloor.size()>0){
                                                         ui->getrobotfloor->setCurrentText(robotfloor);
                                                    }

                                                    qDebug()<<"===11======= "<<arg1;
                                              }
                                              return;
                                         }
                                          iter++;
                                      }

             }

             qDebug()<<"=endn==222223444= "<<arg1;
    } catch (exception e) {
 qDebug()<<"=endn=exception= ";
    }




}


//切换地图
void Widget::on_setRobotPose_clicked()
{

    try {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        ///api/switchMap?mapName=mapName&robotfloor=robotfloor
        QString editmapname = ui->mapnames->currentText();
        QString editrobotfloor = ui->getrobotfloor->currentText();
        QString msge="/api/switchMap?";
        msge=msge+"mapName="+editmapname+"&robotfloor="+editrobotfloor;
        IIMTDriver::getInstance()->sendMsg(msge);

        //显示日志
        QString mesglog="发送 -> 切换地图 sendMsg： "+msge;
        show_console(mesglog,"get");

        //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
       // add_single_instructionQueue_sendMsg(-1 , msge , 1, mesglog, "get");
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }

}
//保存地图
void Widget::on_savemap_clicked()
{


    try {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        ///api/saveMap?mapName=mapName&robotfloor=robotfloor
        QString editmapname = ui->editmapname->text();
        QString editrobotfloor = ui->editrobotfloor->text();
        QString msge="/api/saveGmappingMap?"; //保存Gmapping地图
       // QString msg="/api/saveCartographerMap?";//保存Cartographer地图
        msge=msge+"mapName="+editmapname+"&robotfloor="+editrobotfloor;
        IIMTDriver::getInstance()->sendMsg(msge);
        //显示日志
        QString mesglog="发送 -> 保存地图 sendMsg： "+msge;
        show_console(mesglog,"get");

        //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
        //add_single_instructionQueue_sendMsg(-1 , msge , 1, mesglog, "get");
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }


}
//软急停
void Widget::on_startDisinfectlamp_clicked()
{

//注意： 软件急停也不走队列 处理数据 add_single_instructionQueue_sendMsg
    try {


       // static int flag =1;

            if(startDisinfectlampflag==0){
                //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
                fistsendMsg= 1;
                startDisinfectlampflag =1;

                QString mage=" /api/estop?flag=false ";//失能false
                //向无人车发送消息
                IIMTDriver::getInstance()->sendMsg(mage);
                ui->startDisinfectlamp->setStyleSheet(tr("border-image: url(:/images/关.png);"));

                qDebug()<<"软急停 flag=true";
                //显示日志
                QString mesglog="发送 -> 软急停 sendMsg： "+mage;
               show_console(mesglog,"get");

               //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
               fistsendMsg= -1;


            }else{
                startDisinfectlampflag =0;
                //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
                fistsendMsg= 1;
                QString mage=" /api/estop?flag=true ";//使能true/
                //向通用底盘发送消息
                IIMTDriver::getInstance()->sendMsg(mage);
                qDebug()<<"软急停 flag=false";
                ui->startDisinfectlamp->setStyleSheet(tr("border-image: url(:/images/开.png);"));
                //显示日志
                QString mesglog="发送 -> 软急停 sendMsg： "+mage;
                show_console(mesglog,"send");
                //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
                fistsendMsg= -1;

            }
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }

}

//键盘控制
void Widget::on_keyEventjinapan_clicked()
{

    try {
        int fi =  ui->editFirst->currentIndex();
        int se =  ui->editSecond->currentIndex();
        int th =  ui->editThird->currentIndex();
        int fo =  ui->editFourth->currentIndex();
        if(fi!=0 || se!=0 ||th!=0 || fo != 0 ){
           QMessageBox::about(this, tr("警告："), "请按停止键或请等待正在执行的任务结束！");
           return;
        }
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        //不管打开还是关闭都必须先停止小车运行
        QString msg="/api/currency_teleop_key?keyboard=";
        msg=msg+"s";
        //向通用底盘发送消息，注意： 键盘时时操作，不能通过队列执行
        IIMTDriver::getInstance()->sendMsg(msg);
        QString mesglog="发送 -> 键盘控制"+msg;
        show_console(mesglog,"get");

        //-----------------------------------

        // keyEventjinapanflg
        //true/false,

        static int flag =0;
            if(flag==0){
                //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
                fistsendMsg= 1;

                flag =1;

                ui->keyEventjinapan->setStyleSheet(tr("border-image: url(:/images/开.png);"));
                keyEventjinapanflg="true";
                qDebug()<<"键盘控制: "<<keyEventjinapanflg;
                //显示日志
                QString mesglog="打开键盘控制!";
                show_console(mesglog,"get");


            }else{
                flag =0;
                //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
                fistsendMsg= -1;
                keyEventjinapanflg="false";
                 qDebug()<<"键盘控制: "<<keyEventjinapanflg;

                ui->keyEventjinapan->setStyleSheet(tr("border-image: url(:/images/关.png);"));
                //显示日志
                QString mesglog="关闭键盘控制!";
                show_console(mesglog,"send");

            }
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }

}
// 建图 https://blog.51cto.com/u_12369060/3435703
void Widget::on_jinmap_clicked()
{

    try {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;
        // jinmap
        // /api/createGmappingMap  启动Gmapping建地图服务
        // /api/createCartographerMap 启动Cartographer建地图服务
       // static int flag =0;

            if(jinmapflag_status==0){
                jinmapflag_status =1;

                ui->jinmap->setStyleSheet(tr("border-image: url(:/images/开.png);"));
                jinmapflg="true";
                qDebug()<<"启动建图服务: "<<jinmapflg;
                QString msg="/api/createGmappingMap";
               //QString msg="/api/createCartographerMap";
                //向通用底盘发送消息
              IIMTDriver::getInstance()->sendMsg(msg);

                //显示日志
                QString mesglog="发送 -> 启动建图服务 sendMsg： "+msg;
                show_console(mesglog,"get");
                //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
              //  add_single_instructionQueue_sendMsg(-1 , msg , 1,mesglog, "get");

            }else{
                jinmapflag_status =0;
                jinmapflg="false";
                 qDebug()<<"关闭建地图服务: "<<jinmapflg;
                ui->jinmap->setStyleSheet(tr("border-image: url(:/images/关.png);"));
                QString msg="/api/killGmappingCreateMap";//关闭Gmapping建地图服务
             //   QString msg="/api/killCartographerCreateMap";//关闭建Cartographer地图服务
                //向通用底盘发送消息
               IIMTDriver::getInstance()->sendMsg(msg);

                //显示日志
                QString mesglog="发送 -> 关闭建地图服务 sendMsg： "+msg;
                show_console(mesglog,"send");

                //向队列中添加需要发送的tcp数据(单个数据添加) 参数1 repeat：是否循环发送 -1:不循环发送 1：循环一直发送 | 参数2 sendMsg：需要tcp发送的消息 | 参数3 logdFlg：是否需要记录日志 -1:不记录日志 1：记录日志| 参数4：logdMsg 需要记录的日志内容| 参数5 logColor：日志显示的颜色 get:绿色 send：红色
               // add_single_instructionQueue_sendMsg(-1 , msg , 1,mesglog, "get");
            }

            //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
            fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }



}
//键盘控制指令
void Widget::keyPressEvent(QKeyEvent * event)
{

    /**
      * 键盘指令：
      * /api/currency_teleop_key?keyboard=w
      *
      *               w
      *   keyboard    a    s    d
      *               x
      * 键盘时时操作，不通过队列执行  add_single_instructionQueue_sendMsg(-1 , msg , 1,mesglog, "get");
      */


    try {
        QString msg="/api/currency_teleop_key?keyboard=";

        if(keyEventjinapanflg=="false")
            return;

        switch (event->key())
        {
        case Qt::Key_D:

            qDebug() <<"d";
            msg=msg+"d";
            //向通用底盘发送消息
            IIMTDriver::getInstance()->sendMsg(msg);

            break;
        case Qt::Key_W:
            qDebug() <<"w";
            msg=msg+"w";
            //向通用底盘发送消息
            IIMTDriver::getInstance()->sendMsg(msg);
            break;
        case Qt::Key_A:
            qDebug() <<"a";
            msg=msg+"a";
            //向通用底盘发送消息
            IIMTDriver::getInstance()->sendMsg(msg);
            break;
        case Qt::Key_X:
            qDebug() <<"x";
            msg=msg+"x";
            //向通用底盘发送消息
            IIMTDriver::getInstance()->sendMsg(msg);
            break;
        case Qt::Key_S:
            qDebug() <<"s";
            msg=msg+"s";
            //向通用底盘发送消息
            IIMTDriver::getInstance()->sendMsg(msg);
            break;
        case Qt::Key_Escape:
            qDebug() <<"ESC";
            break;
        case Qt::Key_F1:
            qDebug() <<"F1";
            break;
        case Qt::Key_F2:
            qDebug() <<"F2";
            break;
        case Qt::Key_5:
            qDebug() <<"5";
            break;
        case Qt::Key_Back:
            qDebug() <<"Back";
            break;
        case Qt::Key_Enter:
            qDebug() <<"Enter";
            break;
        case Qt::Key_B:
            qDebug() <<"B";
            break;
        case Qt::Key_C:
            qDebug() <<"C";
            break;
        default:
            qDebug() << event->key();
            break;
        }

        //显示日志
       QString mesglog="发送 -> 键盘指令 sendMsg： "+msg;
       show_console(mesglog,"get");
    } catch (exception e) {

    }

}

 //清除日志
void Widget::on_tiaoshidemo_clicked()
{
ui->textEdit->clear();
//显示日志
QString mesglog="清除日志";
show_console(mesglog,"get");
}
// 显示所有日志 allLog
void Widget::on_allLog_clicked()
{
    try {

        static int flag =0;
            if(flag==0){
                flag =1;

                ui->allLog->setStyleSheet(tr("border-image: url(:/images/开.png);"));
                logall=1;
                qDebug()<<"打开显示所有日志: "<<logall;
                //显示日志
                QString mesglog="打开显示所有日志!";
                show_console(mesglog,"get");

            }else{
                flag =0;
                logall=-1;
                 qDebug()<<"关闭显示所有日志: "<<logall;

                ui->allLog->setStyleSheet(tr("border-image: url(:/images/关.png);"));
                //显示日志
                QString mesglog="关闭显示所有日志!";
                show_console(mesglog,"send");

            }
    } catch (exception e) {

    }
}
//返回充电
void Widget::on_batteryChargeing_clicked()
{
    if(keyEventjinapanflg=="true"){
     QMessageBox::about(this, tr("警告："), "请关闭键盘控制！");
        return;
    }

    if(start_clickedflg==-1){
         QMessageBox::about(this, tr("提示："), "当前有任务正在执行，请等待任务完成或这停止任务");
         return;
    }
    try {

        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/chargeQrcode?state=startchargeing&message=message&taskName=taskName";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 返回充电 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }



}
//自动重新连接
void Widget::on_setStcmBtn_clicked()
{
    //断开robot，自动重新连接
    IIMTDriver::getInstance()->disConnectToRobot();
}
//重启导航
void Widget::on_getStcmBtn_clicked()
{
    try {

        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/restartMovebase";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 重启导航 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }
}
//获取node节点名字
void Widget::on_help_clicked()
{
    try {

        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/getNodeNameList?request_type=nodeNameList";
      //    QString mage="/api/getNodeNameList?request_type=topicNameList";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 获取node节点名字 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }
}
//发送指令
void Widget::on_sendMessage_clicked()
{


  try {

      //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
      fistsendMsg= 1;

      //发送指令
    QString sendMessage = ui->sendMessageEdit->text();
    if(sendMessage.size()<=0){

        //显示日志
        QString mesglog="发送 -> 指令 sendMsg：请填写指令！";
        show_console(mesglog,"get");
        return;
    }


      //向无人车发送消息
        IIMTDriver::getInstance()->sendMsg(sendMessage);
        //显示日志
        QString mesglog="发送 -> 指令 sendMsg： "+sendMessage;
        show_console(mesglog,"get");
        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
  } catch (exception e) {
      //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
      fistsendMsg= -1;
  }
}

//对桩充电
void Widget::on_startchargeing_clicked()
{
    try {

        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/chargeQrcodeTest?state=startchargeing";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 对桩充电 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }
}
//停止对桩
void Widget::on_chargeingStop_clicked()
{
    try {

        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/chargeQrcodeTest?state=chargeingStop";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 停止对桩 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }
}
//离桩
void Widget::on_chargeingOff_clicked()
{
    try {

        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/chargeQrcodeTest?state=chargeingOff";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 离桩 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }
}
//自检
void Widget::on_automaticDetectionServer_clicked()
{
    try {

        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/automaticDetectionServer";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> robot自检 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }
}
//获取topic
void Widget::on_getTopics_clicked()
{
    try {

        //是否优先执行这条数据 | 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= 1;

          QString mage="/api/getNodeNameList?request_type=topicNameList";
        //向无人车发送消息
          IIMTDriver::getInstance()->sendMsg(mage);
          //显示日志
          QString mesglog="发送 -> 获取topic名字 sendMsg： "+mage;
          show_console(mesglog,"get");
          //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
          fistsendMsg= -1;
    } catch (exception e) {
        //是否优先执行这条数据 1：队列中常用数据等待，单个数据发送优先（fistsendMsg== 1）return; -1：队列中常用数据一直轮训发送
        fistsendMsg= -1;
    }
}


//定时任务
void Widget::on_start_KSDemoDlgTask_clicked()
{
    try {
        dlgtaskTme->show();
        //显示日志
        QString mesglog="定时任务 dlgtaskTme->show()";
        show_console(mesglog,"get");

    } catch (exception e) {

    }


}


//虚拟墙
void Widget::on_costMapPlayer_clicked()
{
    try {
        dlgtaskCostMapPlayer->show();
        //显示日志
        QString mesglog="虚拟墙 dlgtaskCostMapPlayer->show()";
        show_console(mesglog,"get");

    } catch (exception e) {

    }



}
//授权slam
void Widget::on_registerService_clicked()
{


        try {
            registerService->show();
            //显示日志
            QString mesglog="授权slam系统 registerService->show()";
            show_console(mesglog,"get");

        } catch (exception e) {

        }
}
